package com.liannong.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.liannong.common.Result;
import com.liannong.entity.Order;
import com.liannong.entity.Product;
import com.liannong.service.OrderService;
import com.liannong.service.ProductService;
import com.liannong.vo.OrderVO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Map;

@RestController
@RequestMapping("/order")
public class OrderController {
    
    private static final Logger logger = LoggerFactory.getLogger(OrderController.class);

    @Autowired
    private OrderService orderService;
    
    @Autowired
    private ProductService productService;

    /**
     * 创建订单
     * @param orderData 订单数据
     * @return 订单ID
     */
    @PostMapping("/create")
    public Result create(@RequestBody Map<String, Object> orderData) {
        logger.info("收到创建订单请求 - 数据: {}", orderData);
        
        try {
            // 获取订单基本信息
            Integer userId = (Integer) orderData.get("userId");
            Integer productId = (Integer) orderData.get("productId");
            Integer quantity = (Integer) orderData.get("quantity");
            String deliveryAddress = (String) orderData.get("deliveryAddress");
            
            // 验证必要参数
            if (userId == null || productId == null || quantity == null || deliveryAddress == null) {
                return Result.error("400", "参数不完整");
            }
            
            // 查询商品信息
            Product product = productService.getById(productId);
            if (product == null) {
                return Result.error("404", "商品不存在");
            }
            
            // 创建订单对象
            Order order = new Order();
            order.setUserId(userId);
            order.setProductId(productId);
            order.setQuantity(quantity);
            order.setTotalPrice(product.getPrice().multiply(new BigDecimal(quantity)));
            order.setStatus(0); // 待处理
            order.setDeliveryAddress(deliveryAddress);
            order.setTraceCode(product.getTraceCode()); // 使用商品的溯源码
            order.setCreateTime(LocalDateTime.now());
            
            // 保存订单
            Integer orderId = orderService.createOrder(order);
            
            return Result.success(orderId);
        } catch (Exception e) {
            logger.error("创建订单失败", e);
            return Result.error("500", "创建订单失败: " + e.getMessage());
        }
    }

    /**
     * 查询订单列表
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @param orderNo 订单号（可选）
     * @param userId 用户ID（可选，默认从当前登录用户获取）
     * @param roleId 角色ID（可选，默认从当前登录用户获取）
     * @return 订单列表
     */
    @GetMapping("/findAll")
    public Result findAll(
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize,
            @RequestParam(required = false) String orderNo,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) Integer roleId) {
        
        logger.info("收到查询订单列表请求 - pageNum: {}, pageSize: {}, orderNo: {}, userId: {}, roleId: {}", 
                    pageNum, pageSize, orderNo, userId, roleId);
        
        try {
            // 如果未提供用户ID或角色ID，从当前登录用户获取
            if (userId == null || roleId == null) {
                // 这里应该从会话或token中获取当前用户信息
                // 假设有一个工具类或服务可以获取当前用户
                // CurrentUser currentUser = userService.getCurrentUser();
                // 示例默认值，实际项目中应替换为真实获取逻辑
                if (userId == null) {
                    userId = 1; // 从当前登录用户获取
                }
                if (roleId == null) {
                    roleId = 3; // 从当前登录用户获取
                }
            }
            
            // 根据用户角色判断查询权限，调用服务层方法
            IPage<OrderVO> page = orderService.findOrdersByUserPermission(userId, roleId, orderNo, pageNum, pageSize);
            return Result.success(page);
        } catch (Exception e) {
            logger.error("查询订单列表失败", e);
            return Result.error("500", "查询订单列表失败: " + e.getMessage());
        }
    }

    /**
     * 根据用户权限获取订单列表
     * @param userId 用户ID
     * @param roleId 角色ID
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @param orderNo 订单号（可选）
     * @return 订单列表
     */
    @GetMapping("/list")
    public Result listByPermission(
            @RequestParam Integer userId,
            @RequestParam Integer roleId,
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize,
            @RequestParam(required = false) String orderNo) {
        
        logger.info("收到按权限查询订单列表请求 - userId: {}, roleId: {}, pageNum: {}, pageSize: {}, orderNo: {}", 
                    userId, roleId, pageNum, pageSize, orderNo);
        
        try {
            IPage<OrderVO> page = orderService.findOrdersByUserPermission(userId, roleId, orderNo, pageNum, pageSize);
            return Result.success(page);
        } catch (Exception e) {
            logger.error("按权限查询订单列表失败", e);
            return Result.error("500", "查询订单列表失败: " + e.getMessage());
        }
    }

    /**
     * 支付订单
     * @param orderId 订单ID
     * @return 支付结果
     */
    @PostMapping("/pay/{orderId}")
    public Result pay(@PathVariable Integer orderId) {
        logger.info("收到支付订单请求 - orderId: {}", orderId);
        
        try {
            boolean success = orderService.payOrder(orderId);
            if (success) {
                return Result.success();
            } else {
                return Result.error("400", "支付失败");
            }
        } catch (Exception e) {
            logger.error("支付订单失败", e);
            return Result.error("500", "支付订单失败: " + e.getMessage());
        }
    }

    /**
     * 取消订单
     * @param orderId 订单ID
     * @return 取消结果
     */
    @PostMapping("/cancel/{orderId}")
    public Result cancel(@PathVariable Integer orderId) {
        logger.info("收到取消订单请求 - orderId: {}", orderId);
        
        try {
            boolean success = orderService.cancelOrder(orderId);
            if (success) {
                return Result.success();
            } else {
                return Result.error("400", "取消失败");
            }
        } catch (Exception e) {
            logger.error("取消订单失败", e);
            return Result.error("500", "取消订单失败: " + e.getMessage());
        }
    }

    /**
     * 更新订单配送状态
     * @param orderId 订单ID
     * @param toDelivery 是否配送
     * @return 更新结果
     */
    @PostMapping("/updateDelivery/{orderId}")
    public Result updateDelivery(
            @PathVariable Integer orderId,
            @RequestParam Boolean toDelivery,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) Integer roleId) {
        logger.info("收到更新订单配送状态请求 - orderId: {}, toDelivery: {}, userId: {}, roleId: {}", 
                    orderId, toDelivery, userId, roleId);
        
        try {
            // 如果未提供用户ID或角色ID，从当前登录用户获取
            if (userId == null) {
                userId = 1; // 从当前登录用户获取，示例默认值
            }
            
            if (roleId == null) {
                roleId = 3; // 从当前登录用户获取，示例默认值
            }
            
            // 检查权限：只有管理员(角色ID为1或2)才能修改配送状态
            if (roleId == 3) {
                return Result.error("403", "权限不足，普通用户不能修改配送状态");
            }
            
            boolean success = orderService.updateDeliveryStatus(orderId, toDelivery);
            if (success) {
                return Result.success();
            } else {
                return Result.error("400", "更新配送状态失败");
            }
        } catch (Exception e) {
            logger.error("更新订单配送状态失败", e);
            return Result.error("500", "更新订单配送状态失败: " + e.getMessage());
        }
    }

    /**
     * 获取订单详情
     * @param orderId 订单ID
     * @param userId 用户ID（可选，默认从当前登录用户获取）
     * @param roleId 角色ID（可选，默认从当前登录用户获取）
     * @return 订单详情
     */
    @GetMapping("/detail/{orderId}")
    public Result detail(
            @PathVariable Integer orderId,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) Integer roleId) {
        logger.info("收到查询订单详情请求 - orderId: {}, userId: {}, roleId: {}", orderId, userId, roleId);
        
        try {
            // 如果未提供用户ID或角色ID，可以从当前登录用户获取
            if (userId == null) {
                // 从当前登录用户获取
                userId = 1; // 示例默认值，实际需要从会话或token中获取
            }
            
            if (roleId == null) {
                // 从当前登录用户获取
                roleId = 3; // 示例默认值，实际需要从会话或token中获取
            }
            
            OrderVO orderVO = orderService.getOrderDetail(orderId);
            if (orderVO == null) {
                return Result.error("404", "订单不存在");
            }
            
            // 检查权限：只有管理员或者订单所有者才能查看订单详情
            if (roleId != 1 && roleId != 2 && !orderVO.getUserId().equals(userId)) {
                return Result.error("403", "没有权限查看此订单");
            }
            
            return Result.success(orderVO);
        } catch (Exception e) {
            logger.error("查询订单详情失败", e);
            return Result.error("500", "查询订单详情失败: " + e.getMessage());
        }
    }
} 